home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gdevm1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-17  |  21.7 KB  |  686 lines
  1. /* Copyright (C) 1989, 1995, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevm1.c */
  20. /* Monobit "memory" (stored bitmap) device */
  21. #include "memory_.h"
  22. #include "gx.h"
  23. #include "gxdevice.h"
  24. #include "gxdevmem.h"            /* semi-public definitions */
  25. #include "gdevmem.h"            /* private definitions */
  26.  
  27. extern dev_proc_strip_copy_rop(mem_mono_strip_copy_rop);  /* in gdevmrop.c */
  28.  
  29. /* Optionally, use the slow RasterOp implementations for testing. */
  30. /*#define USE_COPY_ROP*/
  31.  
  32. #ifdef USE_COPY_ROP
  33. #include "gsrop.h"
  34. #endif
  35.  
  36. /* ================ Standard (byte-oriented) device ================ */
  37.  
  38. /* We went to a lot of trouble to optimize mem_mono_tile_rectangle. */
  39. /* It has a substantial effect on the total time at high resolutions. */
  40. /* However, it takes quite a lot of code, so we omit it on 16-bit systems. */
  41. #define OPTIMIZE_TILE (arch_sizeof_int > 2)
  42.  
  43. /* Procedures */
  44. private dev_proc_map_rgb_color(mem_mono_map_rgb_color);
  45. private dev_proc_map_color_rgb(mem_mono_map_color_rgb);
  46. private dev_proc_copy_mono(mem_mono_copy_mono);
  47. private dev_proc_fill_rectangle(mem_mono_fill_rectangle);
  48. #if OPTIMIZE_TILE
  49. private dev_proc_strip_tile_rectangle(mem_mono_strip_tile_rectangle);
  50. #else
  51. #  define mem_mono_strip_tile_rectangle gx_default_strip_tile_rectangle
  52. #endif
  53.  
  54. /* The device descriptor. */
  55. /* The instance is public. */
  56. const gx_device_memory far_data mem_mono_device =
  57.   mem_full_alpha_device("image1", 0, 1, mem_open,
  58.     mem_mono_map_rgb_color, mem_mono_map_color_rgb,
  59.     mem_mono_copy_mono, gx_default_copy_color, mem_mono_fill_rectangle,
  60.     mem_get_bits, gx_default_map_cmyk_color, gx_no_copy_alpha,
  61.     mem_mono_strip_tile_rectangle, mem_mono_strip_copy_rop);
  62.  
  63. /* Map color to/from RGB.  This may be inverted. */
  64. private gx_color_index
  65. mem_mono_map_rgb_color(gx_device *dev, gx_color_value r, gx_color_value g,
  66.   gx_color_value b)
  67. {    return (gx_default_w_b_map_rgb_color(dev, r, g, b) ^
  68.         mdev->palette.data[0]) & 1;
  69. }
  70. private int
  71. mem_mono_map_color_rgb(gx_device *dev, gx_color_index color,
  72.   gx_color_value prgb[3])
  73. {    return gx_default_w_b_map_color_rgb(dev,
  74.             (color ^ mdev->palette.data[0]) & 1,
  75.             prgb);
  76. }
  77.  
  78. /* Fill a rectangle with a color. */
  79. private int
  80. mem_mono_fill_rectangle(gx_device *dev, int x, int y, int w, int h,
  81.   gx_color_index color)
  82. {
  83. #ifdef USE_COPY_ROP
  84.     return mem_mono_copy_rop(dev, NULL, 0, 0, gx_no_bitmap_id, NULL,
  85.                  NULL, NULL,
  86.                  x, y, w, h, 0, 0,
  87.                  (color ? rop3_1 : rop3_0));
  88. #else
  89.     fit_fill(dev, x, y, w, h);
  90.     bits_fill_rectangle(scan_line_base(mdev, y), x, mdev->raster,
  91.                 -(mono_fill_chunk)color, w, h);
  92.     return 0;
  93. #endif
  94. }
  95.  
  96. /* Convert x coordinate to byte offset in scan line. */
  97. #define x_to_byte(x) ((x) >> 3)
  98.  
  99. /* Copy a monochrome bitmap. */
  100. #undef mono_masks
  101. #define mono_masks mono_copy_masks
  102.  
  103. /* Fetch a chunk from the source. */
  104. /* The source data are always stored big-endian. */
  105. /* Note that the macros always cast cptr, */
  106. /* so it doesn't matter what the type of cptr is. */
  107. /* cshift = chunk_bits - shift. */
  108. #undef chunk
  109. #if arch_is_big_endian
  110. #  define chunk uint
  111. #  define cfetch_right(cptr, shift, cshift)\
  112.     (cfetch_aligned(cptr) >> shift)
  113. #  define cfetch_left(cptr, shift, cshift)\
  114.     (cfetch_aligned(cptr) << shift)
  115. /* Fetch a chunk that straddles a chunk boundary. */
  116. #  define cfetch2(cptr, cskew, skew)\
  117.     (cfetch_left(cptr, cskew, skew) +\
  118.      cfetch_right((const chunk *)(cptr) + 1, skew, cskew))
  119. #else                /* little-endian */
  120. #  define chunk bits16
  121. private const bits16 right_masks2[9] = {
  122.     0xffff, 0x7f7f, 0x3f3f, 0x1f1f, 0x0f0f, 0x0707, 0x0303, 0x0101, 0x0000
  123. };
  124. private const bits16 left_masks2[9] = {
  125.     0xffff, 0xfefe, 0xfcfc, 0xf8f8, 0xf0f0, 0xe0e0, 0xc0c0, 0x8080, 0x0000
  126. };
  127. #  define ccont(cptr, off) (((const chunk *)(cptr))[off])
  128. #  define cfetch_right(cptr, shift, cshift)\
  129.     ((shift) < 8 ?\
  130.      ((ccont(cptr, 0) >> (shift)) & right_masks2[shift]) +\
  131.       (ccont(cptr, 0) << (cshift)) :\
  132.      ((chunk)*(const byte *)(cptr) << (cshift)) & 0xff00)
  133. #  define cfetch_left(cptr, shift, cshift)\
  134.     ((shift) < 8 ?\
  135.      ((ccont(cptr, 0) << (shift)) & left_masks2[shift]) +\
  136.       (ccont(cptr, 0) >> (cshift)) :\
  137.      ((ccont(cptr, 0) & 0xff00) >> (cshift)) & 0xff)
  138. /* Fetch a chunk that straddles a chunk boundary. */
  139. /* We can avoid testing the shift amount twice */
  140. /* by expanding the cfetch_left/right macros in-line. */
  141. #  define cfetch2(cptr, cskew, skew)\
  142.     ((cskew) < 8 ?\
  143.      ((ccont(cptr, 0) << (cskew)) & left_masks2[cskew]) +\
  144.       (ccont(cptr, 0) >> (skew)) +\
  145.       (((chunk)(((const byte *)(cptr))[2]) << (cskew)) & 0xff00) :\
  146.      (((ccont(cptr, 0) & 0xff00) >> (skew)) & 0xff) +\
  147.       ((ccont(cptr, 1) >> (skew)) & right_masks2[skew]) +\
  148.        (ccont(cptr, 1) << (cskew)))
  149. #endif
  150. /* Since source and destination are both always big-endian, */
  151. /* fetching an aligned chunk never requires byte swapping. */
  152. #  define cfetch_aligned(cptr)\
  153.     (*(const chunk *)(cptr))
  154.  
  155. /* copy_function and copy_shift get added together for dispatch */
  156. typedef enum {
  157.     copy_or = 0, copy_store, copy_and, copy_funny
  158. } copy_function;
  159. /* copy_right/left is not an enum, because compilers complain about */
  160. /* an enumeration clash when these are added to a copy_function. */
  161. #define copy_right ((copy_function)0)
  162. #define copy_left ((copy_function)4)
  163. typedef struct {
  164.     short invert;
  165.     ushort op;            /* copy_function */
  166. } copy_mode;
  167. /* Map from <c0,c1> to copy_mode. */
  168. #define cm(i,op) { i, (ushort)op }
  169. private copy_mode copy_modes[9] = {
  170.     cm(-1, copy_funny),        /* NN */
  171.     cm(-1, copy_and),        /* N0 */
  172.     cm(0, copy_or),            /* N1 */
  173.     cm(0, copy_and),        /* 0N */
  174.     cm(0, copy_funny),        /* 00 */
  175.     cm(0, copy_store),        /* 01 */
  176.     cm(-1, copy_or),        /* 1N */
  177.     cm(-1, copy_store),        /* 10 */
  178.     cm(0, copy_funny),        /* 11 */
  179. };
  180. private int
  181. mem_mono_copy_mono(gx_device *dev,
  182.   const byte *base, int sourcex, int sraster, gx_bitmap_id id,
  183.   int x, int y, int w, int h, gx_color_index zero, gx_color_index one)
  184. {
  185. #ifdef USE_COPY_ROP
  186.     return mem_mono_copy_rop(dev, base, sourcex, sraster, id, NULL,
  187.                  NULL, NULL,
  188.                  x, y, w, h, 0, 0,
  189.                  ((zero == gx_no_color_index ? rop3_D :
  190.                    zero == 0 ? rop3_0 : rop3_1) & ~rop3_S) |
  191.                  ((one ==  gx_no_color_index ? rop3_D :
  192.                    one == 0 ? rop3_0 : rop3_1) & rop3_S));
  193. #else                /* !USE_COPY_ROP */
  194.     register const byte *bptr;        /* actually chunk * */
  195.     int dbit, wleft;
  196.     uint mask;
  197.     copy_mode mode;
  198. #define function (copy_function)(mode.op)
  199.     declare_scan_ptr_as(dbptr, byte *);
  200. #define optr ((chunk *)dbptr)
  201.     register int skew;
  202.     register uint invert;
  203.     fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);
  204. #if gx_no_color_index_value != -1        /* hokey! */
  205.     if ( zero == gx_no_color_index ) zero = -1;
  206.     if ( one == gx_no_color_index ) one = -1;
  207. #endif
  208. #define izero (int)zero
  209. #define ione (int)one
  210.     mode = copy_modes[izero + izero + izero + ione + 4];
  211. #undef izero
  212. #undef ione
  213.     invert = (uint)(int)mode.invert;    /* load register */
  214.     setup_rect_as(dbptr, byte *);
  215.     bptr = base + ((sourcex & ~chunk_align_bit_mask) >> 3);
  216.     dbit = x & chunk_align_bit_mask;
  217.     skew = dbit - (sourcex & chunk_align_bit_mask);
  218. /* Macros for writing partial chunks. */
  219. /* The destination pointer is always named optr, */
  220. /* and must be declared as chunk *. */
  221. /* cinvert may be temporarily redefined. */
  222. #define cinvert(bits) ((bits) ^ invert)
  223. #define write_or_masked(bits, mask, off)\
  224.   optr[off] |= (cinvert(bits) & mask)
  225. #define write_store_masked(bits, mask, off)\
  226.   optr[off] = ((optr[off] & ~mask) | (cinvert(bits) & mask))
  227. #define write_and_masked(bits, mask, off)\
  228.   optr[off] &= (cinvert(bits) | ~mask)
  229. /* Macros for writing full chunks. */
  230. #define write_or(bits)  *optr |= cinvert(bits)
  231. #define write_store(bits) *optr = cinvert(bits)
  232. #define write_and(bits) *optr &= cinvert(bits)
  233. /* Macro for incrementing to next chunk. */
  234. #define next_x_chunk\
  235.   bptr += chunk_bytes; dbptr += chunk_bytes
  236. /* Common macro for the end of each scan line. */
  237. #define end_y_loop(sdelta, ddelta)\
  238.   if ( --h == 0 ) break;\
  239.   bptr += sdelta; dbptr += ddelta
  240.     if ( (wleft = w + dbit - chunk_bits) <= 0 )
  241.        {    /* The entire operation fits in one (destination) chunk. */
  242.         set_mono_thin_mask(mask, w, dbit);
  243. #define write_single(wr_op, src)\
  244.   for ( ; ; )\
  245.    { wr_op(src, mask, 0);\
  246.      end_y_loop(sraster, draster);\
  247.    }
  248. #define write1_loop(src)\
  249.   switch ( function ) {\
  250.     case copy_or: write_single(write_or_masked, src); break;\
  251.     case copy_store: write_single(write_store_masked, src); break;\
  252.     case copy_and: write_single(write_and_masked, src); break;\
  253.     default: goto funny;\
  254.   }
  255.         if ( skew >= 0 )    /* single -> single, right/no shift */
  256.         {    if ( skew == 0 )    /* no shift */
  257.             {    write1_loop(cfetch_aligned(bptr));
  258.             }
  259.             else            /* right shift */
  260.             {    int cskew = chunk_bits - skew;
  261.                 write1_loop(cfetch_right(bptr, skew, cskew));
  262.             }
  263.         }
  264.         else if ( wleft <= skew )    /* single -> single, left shift */
  265.         {    int cskew = chunk_bits + skew;
  266.             skew = -skew;
  267.             write1_loop(cfetch_left(bptr, skew, cskew));
  268.         }
  269.         else            /* double -> single */
  270.         {    int cskew = -skew;
  271.             skew += chunk_bits;
  272.             write1_loop(cfetch2(bptr, cskew, skew));
  273.         }
  274. #undef write1_loop
  275. #undef write_single
  276.        }
  277.     else if ( wleft <= skew )
  278.        {    /* 1 source chunk -> 2 destination chunks. */
  279.         /* This is an important special case for */
  280.         /* both characters and halftone tiles. */
  281.         uint rmask;
  282.         int cskew = chunk_bits - skew;
  283.         set_mono_left_mask(mask, dbit);
  284.         set_mono_right_mask(rmask, wleft);
  285. #undef cinvert
  286. #define cinvert(bits) (bits)        /* pre-inverted here */
  287. #if arch_is_big_endian            /* no byte swapping */
  288. #  define write_1to2(wr_op)\
  289.   for ( ; ; )\
  290.    { register uint bits = cfetch_aligned(bptr) ^ invert;\
  291.      wr_op(bits >> skew, mask, 0);\
  292.      wr_op(bits << cskew, rmask, 1);\
  293.      end_y_loop(sraster, draster);\
  294.    }
  295. #else                    /* byte swapping */
  296. #  define write_1to2(wr_op)\
  297.   for ( ; ; )\
  298.    { wr_op(cfetch_right(bptr, skew, cskew) ^ invert, mask, 0);\
  299.      wr_op(cfetch_left(bptr, cskew, skew) ^ invert, rmask, 1);\
  300.      end_y_loop(sraster, draster);\
  301.    }
  302. #endif
  303.         switch ( function )
  304.            {
  305.         case copy_or: write_1to2(write_or_masked); break;
  306.         case copy_store: write_1to2(write_store_masked); break;
  307.         case copy_and: write_1to2(write_and_masked); break;
  308.         default: goto funny;
  309.            }
  310. #undef cinvert
  311. #define cinvert(bits) ((bits) ^ invert)
  312. #undef write_1to2
  313.        }
  314.     else
  315.        {    /* More than one source chunk and more than one */
  316.         /* destination chunk are involved. */
  317.         uint rmask;
  318.         int words = (wleft & ~chunk_bit_mask) >> 3;
  319.         uint sskip = sraster - words;
  320.         uint dskip = draster - words;
  321.         register uint bits;
  322.         set_mono_left_mask(mask, dbit);
  323.         set_mono_right_mask(rmask, wleft & chunk_bit_mask);
  324.         if ( skew == 0 )    /* optimize the aligned case */
  325.            {
  326. #define write_aligned(wr_op, wr_op_masked)\
  327.   for ( ; ; )\
  328.    { int count = wleft;\
  329.      /* Do first partial chunk. */\
  330.      wr_op_masked(cfetch_aligned(bptr), mask, 0);\
  331.      /* Do full chunks. */\
  332.      while ( (count -= chunk_bits) >= 0 )\
  333.       { next_x_chunk; wr_op(cfetch_aligned(bptr)); }\
  334.      /* Do last chunk */\
  335.      if ( count > -chunk_bits )\
  336.       { wr_op_masked(cfetch_aligned(bptr + chunk_bytes), rmask, 1); }\
  337.      end_y_loop(sskip, dskip);\
  338.    }
  339.             switch ( function )
  340.               {
  341.               case copy_or:
  342.                 write_aligned(write_or, write_or_masked);
  343.                 break;
  344.               case copy_store:
  345.                 write_aligned(write_store, write_store_masked);
  346.                 break;
  347.               case copy_and:
  348.                 write_aligned(write_and, write_and_masked);
  349.                 break;
  350.               default:
  351.                 goto funny;
  352.               }
  353. #undef write_aligned
  354.            }
  355.         else            /* not aligned */
  356.            {    int ccase =
  357.               (skew >= 0 ? copy_right :
  358.                ((bptr += chunk_bytes), copy_left))
  359.               + (int)function;
  360.             int cskew = -skew & chunk_bit_mask;
  361.             skew &= chunk_bit_mask;
  362.             for ( ; ; )
  363.                {    int count = wleft;
  364. #define prefetch_right\
  365.   bits = cfetch_right(bptr, skew, cskew)
  366. #define prefetch_left\
  367.   bits = cfetch2(bptr - chunk_bytes, cskew, skew)
  368. #define write_unaligned(wr_op, wr_op_masked)\
  369.   wr_op_masked(bits, mask, 0);\
  370.   /* Do full chunks. */\
  371.   while ( count >= chunk_bits )\
  372.     { bits = cfetch2(bptr, cskew, skew);\
  373.       next_x_chunk; wr_op(bits); count -= chunk_bits;\
  374.     }\
  375.   /* Do last chunk */\
  376.   if ( count > 0 )\
  377.     { bits = cfetch_left(bptr, cskew, skew);\
  378.       if ( count > skew ) bits += cfetch_right(bptr + chunk_bytes, skew, cskew);\
  379.       wr_op_masked(bits, rmask, 1);\
  380.     }
  381.                 switch ( ccase )
  382.                   {
  383.                   case copy_or + copy_left:
  384.                     prefetch_left; goto uor;
  385.                   case copy_or + copy_right:
  386.                     prefetch_right;
  387. uor:                    write_unaligned(write_or, write_or_masked);
  388.                     break;
  389.                   case copy_store + copy_left:
  390.                     prefetch_left; goto ustore;
  391.                   case copy_store + copy_right:
  392.                     prefetch_right;
  393. ustore:                    write_unaligned(write_store, write_store_masked);
  394.                     break;
  395.                   case copy_and + copy_left:
  396.                     prefetch_left; goto uand;
  397.                   case copy_and + copy_right:
  398.                     prefetch_right;
  399. uand:                    write_unaligned(write_and, write_and_masked);
  400.                     break;
  401.                   default:
  402.                     goto funny;
  403.                   }
  404.                 end_y_loop(sskip, dskip);
  405. #undef write_unaligned
  406. #undef prefetch_left
  407. #undef prefetch_right
  408.                }
  409.            }
  410.        }
  411. #undef end_y_loop
  412. #undef next_x_chunk
  413.     return 0;
  414.     /* Handle the funny cases that aren't supposed to happen. */
  415. funny:    return (invert ? gs_note_error(-1) :
  416.         mem_mono_fill_rectangle(dev, x, y, w, h, zero));
  417. #undef optr
  418. #endif                /* !USE_COPY_ROP */
  419. }
  420.  
  421. #if OPTIMIZE_TILE        /**************** ****************/
  422.  
  423. /* Strip-tile with a monochrome halftone. */
  424. /* This is a performance bottleneck for monochrome devices, */
  425. /* so we re-implement it, even though it takes a lot of code. */
  426. private int
  427. mem_mono_strip_tile_rectangle(gx_device *dev,
  428.   register const gx_strip_bitmap *tiles,
  429.   int tx, int y, int tw, int th, gx_color_index color0, gx_color_index color1,
  430.   int px, int py)
  431. {
  432. #ifdef USE_COPY_ROP
  433.     return mem_mono_strip_copy_rop(dev, NULL, 0, 0, tile->id, NULL,
  434.                 tiles, NULL,
  435.                 tx, y, tw, th, px, py,
  436.                 ((color0 == gx_no_color_index ? rop3_D :
  437.                   color0 == 0 ? rop3_0 : rop3_1) & ~rop3_T) |
  438.                 ((color1 ==  gx_no_color_index ? rop3_D :
  439.                   color1 == 0 ? rop3_0 : rop3_1) & rop3_T));
  440. #else                /* !USE_COPY_ROP */
  441.     register uint invert;
  442.     int sraster;
  443.     uint tile_bits_size;
  444.     const byte *base;
  445.     const byte *end;
  446.     int x, rw, w, h;
  447.     register const byte *bptr;        /* actually chunk * */
  448.     int dbit, wleft;
  449.     uint mask;
  450.     byte *dbase;
  451.     declare_scan_ptr_as(dbptr, byte *);
  452. #define optr ((chunk *)dbptr)
  453.     register int skew;
  454.  
  455.     /* This implementation doesn't handle strips yet. */
  456.     if ( color0 != (color1 ^ 1) || tiles->shift != 0 )
  457.       return gx_default_strip_tile_rectangle(dev, tiles, tx, y, tw, th,
  458.                          color0, color1, px, py);
  459.     fit_fill(dev, tx, y, tw, th);
  460.     invert = -(uint)color0;
  461.     sraster = tiles->raster;
  462.     base = tiles->data + ((y + py) % tiles->rep_height) * sraster;
  463.     tile_bits_size = tiles->size.y * sraster;
  464.     end = tiles->data + tile_bits_size;
  465. #undef end_y_loop
  466. #define end_y_loop(sdelta, ddelta)\
  467.   if ( --h == 0 ) break;\
  468.   if ( end - bptr <= sdelta )    /* wrap around */\
  469.     bptr -= tile_bits_size;\
  470.   bptr += sdelta; dbptr += ddelta
  471.     draster = mdev->raster;
  472.     dbase = scan_line_base(mdev, y);
  473.     x = tx;
  474.     rw = tw;
  475.     /*
  476.      * The outermost loop here works horizontally, one iteration per
  477.      * copy of the tile.  Note that all iterations except the first
  478.      * have sourcex = 0.
  479.      */
  480.     { int sourcex = (x + px) % tiles->rep_width;
  481.       w = tiles->size.x - sourcex;
  482.       bptr = base + ((sourcex & ~chunk_align_bit_mask) >> 3);
  483.       dbit = x & chunk_align_bit_mask;
  484.       skew = dbit - (sourcex & chunk_align_bit_mask);
  485.     }
  486. outer:    if ( w > rw )
  487.       w = rw;
  488.     h = th;
  489.     dbptr = dbase + ((x >> 3) & -chunk_align_bytes);
  490.     if ( (wleft = w + dbit - chunk_bits) <= 0 )
  491.        {    /* The entire operation fits in one (destination) chunk. */
  492.         set_mono_thin_mask(mask, w, dbit);
  493. #define write1_loop(src)\
  494.   for ( ; ; )\
  495.    { write_store_masked(src, mask, 0);\
  496.      end_y_loop(sraster, draster);\
  497.    }
  498.         if ( skew >= 0 )    /* single -> single, right/no shift */
  499.         {    if ( skew == 0 )    /* no shift */
  500.             {    write1_loop(cfetch_aligned(bptr));
  501.             }
  502.             else            /* right shift */
  503.             {    int cskew = chunk_bits - skew;
  504.                 write1_loop(cfetch_right(bptr, skew, cskew));
  505.             }
  506.         }
  507.         else if ( wleft <= skew )    /* single -> single, left shift */
  508.         {    int cskew = chunk_bits + skew;
  509.             skew = -skew;
  510.             write1_loop(cfetch_left(bptr, skew, cskew));
  511.         }
  512.         else            /* double -> single */
  513.         {    int cskew = -skew;
  514.             skew += chunk_bits;
  515.             write1_loop(cfetch2(bptr, cskew, skew));
  516.         }
  517. #undef write1_loop
  518.       }
  519.     else if ( wleft <= skew )
  520.       {    /* 1 source chunk -> 2 destination chunks. */
  521.         /* This is an important special case for */
  522.         /* both characters and halftone tiles. */
  523.         uint rmask;
  524.         int cskew = chunk_bits - skew;
  525.         set_mono_left_mask(mask, dbit);
  526.         set_mono_right_mask(rmask, wleft);
  527. #if arch_is_big_endian            /* no byte swapping */
  528. #undef cinvert
  529. #define cinvert(bits) (bits)        /* pre-inverted here */
  530.         for ( ; ; )
  531.           { register uint bits = cfetch_aligned(bptr) ^ invert;
  532.             write_store_masked(bits >> skew, mask, 0);
  533.             write_store_masked(bits << cskew, rmask, 1);
  534.             end_y_loop(sraster, draster);
  535.           }
  536. #undef cinvert
  537. #define cinvert(bits) ((bits) ^ invert)
  538. #else                    /* byte swapping */
  539.         for ( ; ; )
  540.           { write_store_masked(cfetch_right(bptr, skew, cskew), mask, 0);
  541.             write_store_masked(cfetch_left(bptr, cskew, skew), rmask, 1);
  542.             end_y_loop(sraster, draster);
  543.           }
  544. #endif
  545.       }
  546.     else
  547.        {    /* More than one source chunk and more than one */
  548.         /* destination chunk are involved. */
  549.         uint rmask;
  550.         int words = (wleft & ~chunk_bit_mask) >> 3;
  551.         uint sskip = sraster - words;
  552.         uint dskip = draster - words;
  553.         register uint bits;
  554. #define next_x_chunk\
  555.   bptr += chunk_bytes; dbptr += chunk_bytes
  556.  
  557.         set_mono_right_mask(rmask, wleft & chunk_bit_mask);
  558.         if ( skew == 0 )    /* optimize the aligned case */
  559.            {    if ( dbit == 0 )
  560.               mask = 0;
  561.             else
  562.               set_mono_left_mask(mask, dbit);
  563.             for ( ; ; )
  564.               { int count = wleft;
  565.                 /* Do first partial chunk. */
  566.                 if ( mask )
  567.                   write_store_masked(cfetch_aligned(bptr), mask, 0);
  568.                 else
  569.                   write_store(cfetch_aligned(bptr));
  570.                 /* Do full chunks. */
  571.                 while ( (count -= chunk_bits) >= 0 )
  572.                   { next_x_chunk;
  573.                 write_store(cfetch_aligned(bptr));
  574.                   }
  575.                 /* Do last chunk */
  576.                 if ( count > -chunk_bits )
  577.                   { write_store_masked(cfetch_aligned(bptr + chunk_bytes), rmask, 1);
  578.                   }
  579.                 end_y_loop(sskip, dskip);
  580.               }
  581.            }
  582.         else            /* not aligned */
  583.            {    bool case_right =
  584.               (skew >= 0 ? true :
  585.                ((bptr += chunk_bytes), false));
  586.             int cskew = -skew & chunk_bit_mask;
  587.  
  588.             skew &= chunk_bit_mask;
  589.             set_mono_left_mask(mask, dbit);
  590.             for ( ; ; )
  591.                {    int count = wleft;
  592.                 if ( case_right )
  593.                   bits = cfetch_right(bptr, skew, cskew);
  594.                 else
  595.                   bits = cfetch2(bptr - chunk_bytes, cskew, skew);
  596.                 write_store_masked(bits, mask, 0);
  597.                 /* Do full chunks. */
  598.                 while ( count >= chunk_bits )
  599.                   { bits = cfetch2(bptr, cskew, skew);
  600.                     next_x_chunk;
  601.                     write_store(bits);
  602.                     count -= chunk_bits;
  603.                   }
  604.                 /* Do last chunk */
  605.                 if ( count > 0 )
  606.                   { bits = cfetch_left(bptr, cskew, skew);
  607.                     if ( count > skew )
  608.                       bits += cfetch_right(bptr + chunk_bytes, skew, cskew);
  609.                     write_store_masked(bits, rmask, 1);
  610.                   }
  611.                 end_y_loop(sskip, dskip);
  612.                }
  613.            }
  614.        }
  615. #undef end_y_loop
  616. #undef next_x_chunk
  617. #undef optr
  618.     if ( (rw -= w) > 0 )
  619.       {    x += w;
  620.         w = tiles->size.x;
  621.         bptr = base;
  622.         skew = dbit = x & chunk_align_bit_mask;
  623.         goto outer;
  624.       }
  625.     return 0;
  626. #endif                /* !USE_COPY_ROP */
  627. }
  628.  
  629. #endif                /**************** ****************/
  630.  
  631. /* ================ "Word"-oriented device ================ */
  632.  
  633. /* Note that on a big-endian machine, this is the same as the */
  634. /* standard byte-oriented-device. */
  635.  
  636. #if !arch_is_big_endian
  637.  
  638. /* Procedures */
  639. private dev_proc_copy_mono(mem1_word_copy_mono);
  640. private dev_proc_fill_rectangle(mem1_word_fill_rectangle);
  641. #define mem1_word_strip_tile_rectangle gx_default_strip_tile_rectangle
  642.  
  643. /* Here is the device descriptor. */
  644. const gx_device_memory far_data mem_mono_word_device =
  645.   mem_full_alpha_device("image1w", 0, 1, mem_open,
  646.     mem_mono_map_rgb_color, mem_mono_map_color_rgb,
  647.     mem1_word_copy_mono, gx_default_copy_color, mem1_word_fill_rectangle,
  648.     mem_word_get_bits, gx_default_map_cmyk_color, gx_no_copy_alpha,
  649.     mem1_word_strip_tile_rectangle, gx_no_strip_copy_rop);
  650.  
  651. /* Fill a rectangle with a color. */
  652. private int
  653. mem1_word_fill_rectangle(gx_device *dev, int x, int y, int w, int h,
  654.   gx_color_index color)
  655. {    byte *base;
  656.     uint raster;
  657.     fit_fill(dev, x, y, w, h);
  658.     base = scan_line_base(mdev, y);
  659.     raster = mdev->raster;
  660.     mem_swap_byte_rect(base, raster, x, w, h, true);
  661.     bits_fill_rectangle(base, x, raster, -(mono_fill_chunk)color, w, h);
  662.     mem_swap_byte_rect(base, raster, x, w, h, true);
  663.     return 0;
  664. }
  665.  
  666. /* Copy a bitmap. */
  667. private int
  668. mem1_word_copy_mono(gx_device *dev,
  669.   const byte *base, int sourcex, int sraster, gx_bitmap_id id,
  670.   int x, int y, int w, int h, gx_color_index zero, gx_color_index one)
  671. {    byte *row;
  672.     uint raster;
  673.     bool store;
  674.     fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);
  675.     row = scan_line_base(mdev, y);
  676.     raster = mdev->raster;
  677.     store = (zero != gx_no_color_index && one != gx_no_color_index);
  678.     mem_swap_byte_rect(row, raster, x, w, h, store);
  679.     mem_mono_copy_mono(dev, base, sourcex, sraster, id,
  680.                x, y, w, h, zero, one);
  681.     mem_swap_byte_rect(row, raster, x, w, h, false);
  682.     return 0;
  683. }
  684.  
  685. #endif                /* !arch_is_big_endian */
  686.